LearnGraph.online

Appearance

本章介绍: LangGraph 框架基础 ​

开篇寄语

欢迎来到 LangGraph 学习之旅的第一站。作为一位见证了从专家系统到深度学习,再到大语言模型变革的研究者，我深知选择正确的工具框架对于构建成功的 AI 系统至关重要。LangGraph 不仅仅是又一个 Agent 框架，它代表了我们对可控性、可观测性和生产级质量的全新追求。

本章在课程中的定位 ​

在 Module 0 中,你已经掌握了 Python 基础、工程实践和 AI 工具生态。现在,是时候进入 LangGraph 的核心世界了。

本章核心目标 ​

完成本章学习后,你将能够:

  1. 理解框架选择的本质 - 为什么 LangGraph 而不是其他框架?
  2. 掌握 LangChain 生态 - LangGraph 的基础设施
  3. 构建第一个图应用 - 从理论到实践
  4. 建立系统性认知 - 理解图、节点、状态的深层含义

为什么 Module 1 如此重要? ​

这一章不仅是技术学习,更是思维模式的转变:

传统思维: 线性调用链 → LLM → 工具 → 输出
图思维:   状态驱动 → 节点网络 → 条件路由 → 可控循环

关键洞察:

LangGraph 的本质是将 Agent 的执行过程从"黑盒"变为"白盒",从"希望它工作"变为"确保它按预期工作"。这是从实验室原型到生产系统的根本转变。

本章内容结构 ​

本章采用从对比到实践的渐进式学习路径:

1.1 LangGraph 与其它框架对比 ​

核心问题: 在众多 Agent 框架中,为什么选择 LangGraph?

这一节将带你深入分析主流框架:

对比维度 ​

框架特性LangGraphCrewAIAutoGenSwarm
架构理念图状态机角色协作对话编排轻量协调
状态管理⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐
可控性精确控制中等自主性强简单
生产就绪✅ 完全⚠️ 部分✅ 企业级❌ 实验性
学习曲线陡峭但值得平缓中等极简

关键决策点 ​

选择 LangGraph 的场景:

  • ✅ 需要精确控制执行流程
  • ✅ 复杂的条件分支和循环
  • ✅ 生产环境的可靠性要求
  • ✅ 需要 Human-in-the-Loop
  • ✅ 可观测性和调试能力

其他框架更适合:

  • CrewAI: 快速原型,角色分工明确的简单场景
  • AutoGen: 代码生成,Microsoft 生态系统
  • Swarm: 实验性项目,最小化实现

关键洞察:

框架选择不是"最好",而是"最合适"。LangGraph 的优势在于将灵活性和可控性结合,这在生产环境中至关重要。

学习重点:

  • 理解图状态机 vs 线性执行的本质差异
  • 认识到可控性在生产环境中的价值
  • 建立框架选择的决策思维

时间投入: 1-2 小时

1.2 LangGraph 上手案例 ​

核心问题: 如何快速构建第一个 LangGraph 应用?

这一节通过一个情绪生成器案例,让你立即动手实践:

案例架构 ​

用户输入: "Hi, this is Lance."
    ↓
[START]
    ↓
[Node 1: add_i_am] 添加 "I am"
    ↓
[条件边: decide_mood] 随机选择
    ↓
  ┌─────────┐
  ↓         ↓
[happy]   [sad]
  ↓         ↓
  └────┬────┘
       ↓
     [END]
       ↓
输出: "Hi, this is Lance. I am happy!"

你将学到 ​

  1. 图的基本组成

    • State: 数据容器
    • Node: 执行单元
    • Edge: 流程控制

  2. 第一次编码体验

    python
    from langgraph.graph import StateGraph, START, END

# 定义状态
class State(TypedDict):
    graph_state: str

# 定义节点
def node_1(state):
    return {"graph_state": state['graph_state'] + " I am"}

# 构建图
graph = StateGraph(State)
graph.add_node("node_1", node_1)
graph.add_edge(START, "node_1")

  3. 条件路由

    python
    def decide_mood(state) -> Literal["happy", "sad"]:
    return random.choice(["happy", "sad"])

graph.add_conditional_edges("node_1", decide_mood)

关键洞察:

图不是静态的流程图,而是动态的执行引擎。每个节点都是状态转换函数: State → State。

学习重点:

  • 理解 StateGraph 的构建模式
  • 掌握条件边的使用方法
  • 建立"状态驱动"的思维

时间投入: 2-3 小时(含动手实践)

1.3 LangChain 快速回顾 ​

核心问题: LangGraph 依赖于 LangChain,我需要了解哪些基础?

这一节是知识桥梁,回顾 LangChain 的核心组件:

必须掌握的概念 ​

1. Chat Models (聊天模型)

python
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4", temperature=0.7)
response = llm.invoke("Hello, world!")

为什么重要: LangGraph 的节点通常会调用 LLM 生成响应。

2. Messages (消息类型)

python
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage

messages = [
    SystemMessage(content="You are a helpful assistant"),
    HumanMessage(content="What is LangGraph?"),
    AIMessage(content="LangGraph is...")
]

为什么重要: LangGraph 的状态经常包含 messages 字段。

3. Tools (工具调用)

python
from langchain_core.tools import tool

@tool
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

tools = [multiply]
llm_with_tools = llm.bind_tools(tools)

为什么重要: Agent 通过工具与外部世界交互。

4. Prompts (提示模板)

python
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a {role}"),
    ("human", "{input}")
])

为什么重要: 结构化的提示是 Agent 行为的基础。

关键洞察:

LangChain 提供"零件",LangGraph 提供"组装图纸"。理解 LangChain 组件是使用 LangGraph 的前提。

学习重点:

  • 熟悉 Chat Models 的基本用法
  • 理解 Messages 的结构
  • 掌握 Tools 的定义和绑定

时间投入: 2-3 小时

1.4 LangGraph 基础入门 ​

核心问题: 如何系统性地理解和使用 LangGraph?

这是本章的核心章节,系统讲解 LangGraph 的基础知识:

核心概念深度解析 ​

1. 图的本质

LangGraph 中的图是一个有向图 (Directed Graph):

  • 节点 (Nodes): 执行具体操作
  • 边 (Edges): 定义执行顺序
  • 状态 (State): 在节点间流动的数据

数学定义:

G = (V, E, S)
其中:
  V = {节点集合}
  E = {边集合: (vi, vj) | vi, vj ∈ V}
  S = {状态空间}

2. 状态管理机制

python
from typing_extensions import TypedDict

class AgentState(TypedDict):
    messages: list[BaseMessage]  # 对话历史
    user_info: dict              # 用户信息
    next_action: str             # 下一步动作

状态更新规则:

python
def node(state: AgentState) -> dict:
    # 读取状态
    current_messages = state["messages"]

    # 处理逻辑
    new_message = process(current_messages)

    # 返回部分更新（重要！）
    return {"messages": [new_message]}  # LangGraph 会自动合并

3. 节点设计模式

模式 1: LLM 调用节点

python
def llm_node(state):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

模式 2: 工具调用节点

python
def tool_node(state):
    tool_calls = state["messages"][-1].tool_calls
    results = [tool.invoke(call) for call in tool_calls]
    return {"messages": results}

模式 3: 决策节点

python
def router(state) -> Literal["tools", "end"]:
    last_message = state["messages"][-1]
    if hasattr(last_message, "tool_calls"):
        return "tools"
    return "end"

4. 边的三种类型

python
# 1. 普通边 (Normal Edge)
graph.add_edge("node_a", "node_b")

# 2. 条件边 (Conditional Edge)
graph.add_conditional_edges(
    "decision_node",
    router_function,
    {"tools": "tool_node", "end": END}
)

# 3. 入口/出口边
graph.add_edge(START, "first_node")
graph.add_edge("last_node", END)

关键洞察:

LangGraph 的强大之处在于显式建模。每个决策点、每个状态变化都是可见、可控、可调试的。

学习重点:

  • 深入理解 State Schema 的设计
  • 掌握节点函数的编写模式
  • 熟练使用条件边实现路由

时间投入: 4-6 小时(含深度实践)

学习方法论 ​

推荐学习路径 ​

Week 1: Day 1-2
├─ 1.1 框架对比 (理解选择)
└─ 1.2 上手案例 (建立感觉)

Week 1: Day 3-5
├─ 1.3 LangChain 回顾 (夯实基础)
└─ 1.4 基础入门 (系统学习)

Week 1: Day 6-7
└─ 综合实践: 构建自己的第一个 Agent

实践建议 ​

  1. 先运行,再理解

    • 复制示例代码,观察输出
    • 修改参数,观察变化
    • 提出假设,验证假设

  2. 绘制概念图

    LangGraph 核心概念
├── StateGraph
│   ├── State Schema
│   ├── Nodes
│   └── Edges
├── Compilation
└── Invocation

  3. 建立代码模板

    python
    # 我的 LangGraph 模板
from langgraph.graph import StateGraph, START, END
from typing_extensions import TypedDict

class State(TypedDict):
    # 定义你的状态
    pass

def node_function(state: State) -> dict:
    # 实现你的逻辑
    return {}

graph = StateGraph(State)
graph.add_node("node_name", node_function)
graph.add_edge(START, "node_name")
graph.add_edge("node_name", END)

app = graph.compile()
result = app.invoke(initial_state)

常见陷阱与避坑指南 ​

❌ 陷阱 1: "我需要先完全理解才能开始编码" ​

正解: 先动手,在实践中理解。LangGraph 的很多概念只有运行代码才能真正领悟。

❌ 陷阱 2: "条件边太复杂,我先跳过" ​

正解: 条件边是 LangGraph 的精髓。它决定了 Agent 的智能程度,必须掌握。

❌ 陷阱 3: "状态设计随意,后期再优化" ​

正解: 状态设计是架构决策。一个好的状态设计事半功倍,后期修改成本极高。

❌ 陷阱 4: "直接跳到 Multi-Agent,单 Agent 太简单" ​

正解: 单 Agent 的模式是 Multi-Agent 的基础。基础不牢,地动山摇。

本章知识图谱 ​

Module 1: LangGraph 框架基础
│
├─ 框架对比与选择
│  ├─ 架构理念差异
│  ├─ 适用场景分析
│  └─ 决策思维模型
│
├─ LangGraph 核心概念
│  ├─ Graph (图)
│  │  ├─ StateGraph
│  │  └─ MessageGraph
│  ├─ State (状态)
│  │  ├─ TypedDict 定义
│  │  ├─ Channels 机制
│  │  └─ 更新规则
│  ├─ Nodes (节点)
│  │  ├─ 函数签名
│  │  ├─ 状态转换
│  │  └─ 设计模式
│  └─ Edges (边)
│     ├─ Normal Edge
│     ├─ Conditional Edge
│     └─ 动态路由
│
├─ LangChain 基础
│  ├─ Chat Models
│  ├─ Messages
│  ├─ Tools
│  └─ Prompts
│
└─ 实践案例
   ├─ 情绪生成器
   ├─ 简单 Agent
   └─ 条件路由示例

给不同背景学习者的建议 ​

如果你是 Python 新手 + AI 初学者 ​

学习路径:

  1. 先完成 Module 0 - 确保 Python 基础扎实
  2. 重点关注 1.2 和 1.4 - 通过案例建立直觉
  3. 暂时跳过 1.1 - 等有实践经验后再回来理解对比
  4. 多运行代码 - 每个示例至少运行 3 次,修改参数观察变化

预计时间: 2 周,每天 3-4 小时

如果你有 Python 经验,但 AI 是新领域 ​

学习路径:

  1. 快速浏览 1.3 - 了解 LangChain 基础
  2. 重点学习 1.4 - 系统理解 LangGraph 架构
  3. 深入研究 1.1 - 建立框架选择的决策思维
  4. 动手改造案例 - 在 1.2 的基础上实现自己的需求

预计时间: 1 周,每天 3-4 小时

如果你是 AI/ML 研究者 ​

学习路径:

  1. 重点阅读 1.1 - 理解 LangGraph 在 Agent 框架谱系中的位置
  2. 快速过 1.2 - 建立基础认知
  3. 深入 1.4 - 理解图执行引擎的实现原理
  4. 思考研究问题: 如何将你的研究成果集成到 LangGraph?

预计时间: 3-5 天,每天 2-3 小时

如果你是架构师/技术 Leader ​

学习路径:

  1. 深入研究 1.1 - 框架选择的技术和商业考量
  2. 重点理解 1.4 的架构设计 - 状态管理、可观测性、可扩展性
  3. 评估生产就绪度:
    • 如何监控?
    • 如何调试?
    • 如何扩展?
    • 成本如何?

预计时间: 2-3 天,每天 2-3 小时

推荐资源 ​

官方资源 (必读) ​

论文与博客 (深入理解) ​

  • ReAct: Reasoning and Acting: 理解 Agent 的思考和行动循环
  • LangGraph Blog: 官方博客的最佳实践文章

社区资源 ​

  • LangChain Discord: 最活跃的讨论社区
  • GitHub Discussions: 技术问题和案例分享

学习成果检验 ​

完成本章后,你应该能够:

✅ 理论检验 ​

  • [ ] 能够解释 LangGraph 与 CrewAI、AutoGen 的本质区别
  • [ ] 能够画出一个典型 LangGraph 应用的架构图
  • [ ] 能够说明为什么需要状态管理
  • [ ] 能够解释条件边的执行机制

✅ 实践检验 ​

  • [ ] 能够独立构建一个 3 节点以上的图
  • [ ] 能够实现至少 1 个条件边
  • [ ] 能够定义合理的 State Schema
  • [ ] 能够调试图的执行流程

✅ 综合检验 ​

挑战任务: 构建一个"智能客服路由系统"

需求:

  1. 接收用户消息
  2. 分析消息意图(问候/问题/投诉/其他)
  3. 根据意图路由到不同的处理节点
  4. 返回合适的响应

评分标准:

  • 基础(60分): 能运行,有条件路由
  • 良好(80分): 状态设计合理,代码清晰
  • 优秀(100分): 有错误处理,可扩展

下一步 ​

完成 Module 1 后,你已经具备了:

  • ✅ LangGraph 的核心知识
  • ✅ 构建简单图的能力
  • ✅ 框架选择的判断力

但这只是开始! 在 Module 2 中,我们将学习:

  • 如何构建生产级的 Agent
  • Chain、Router、Agent 的架构模式
  • 记忆管理和持久化
  • 部署和监控

结语 ​

作为一位研究者,我想分享一个洞察:

框架只是工具,思维才是核心。 LangGraph 的价值不在于它提供了什么 API,而在于它引导我们用"图"的方式思考 Agent 系统。这种思维模式的转变,比任何具体技术都更有价值。

不要追求完美,要追求理解。 不必一开始就写出完美的代码,重要的是理解每个组件的作用,理解状态如何流动,理解决策如何做出。

实践是唯一的老师。 读再多文档,都不如动手写一个简单的 Agent。遇到问题,调试,解决,这个过程才是真正的学习。

准备好了吗?让我们开始 Module 1 的学习之旅!

➡️ [1.1 LangGraph 与其它框架对比](./1.1 LangGraph 1.x.md)

Bryce Wang一位相信"理解本质"胜过"记忆 API"的研究者2025 年 12 月

基于 MIT 许可证发布。内容版权归作者所有。

Copyright © 2025-present 王几行XING（Bryce Wang）